Node / public / rns-proxy / commits / 31b3e9f

Parents : 1c3f3bf

Author : welo | main nixos computer <empty@empty.com>

Date : 2026-07-08T16:25:52+01:00

debug testing

2 files changed, 11 insertions(+), 3 deletions(-)

M src/frame.rs +1

M src/mux.rs +10 -3

--- a/src/frame.rs

+++ b/src/frame.rs

let session_id = u32::from_be_bytes([buf[1], buf[2], buf[3], buf[4]]);

let payload_len = u16::from_be_bytes([buf[5], buf[6]]) as usize;

let total = HDR_SIZE + payload_len;

if buf.len() < total {

return Err(MoreDataRequired);

} else if buf.len() < total {

--- a/src/mux.rs

+++ b/src/mux.rs

/// Note that we are using .inner.link_id.lock as the guard to prevent

/// multiple different sids from sending at the same time and scrambling packets

pub fn send_frame(&self, frame: &Frame) {

Some(id) => id,

None => {

debug!("send_frame: no active link, dropping frame");

let node = &self.inner.node;

// Send in LINK_MDU-sized chunks

for chunk in encoded.chunks(LINK_MDU) {

if let Err(e) = node.send_on_link(link_id.0, chunk.to_vec(), DATA_CONTEXT) {

warn!("Failed to send link data: {:?}", e);

return;

}

}

}

/// Convenience: send a typed frame.

/// Called when `on_link_data` fires. The data may be a partial chunk of a

/// larger frame, so we buffer and try to decode complete frames.

pub fn receive_data(&self, data: &[u8]) -> Vec<Frame> {

let mut buf = self.inner.recv_buf.lock().unwrap();

buf.extend_from_slice(data);

let mut frames = Vec::new();

loop {

match Frame::decode(&buf) {

Ok((frame, consumed)) => {

buf.drain(..consumed);

frames.push(frame);

}

Finished => {

// finished decoding all packets basically

// though there might still be like 5 bytes left in the buffer

break;

}

MoreDataRequired => {

break;

// just wait for next packet

}